/**
 * 编辑单词
 *
 * 给你两个单词 word1 和 word2， 请返回将 word1 转换成 word2 所使用的最少操作数  。
 * 你可以对一个单词进行如下三种操作：
 * 插入一个字符
 * 删除一个字符
 * 替换一个字符
 *
 * 示例 1：
 * 输入：word1 = "horse", word2 = "ros"
 * 输出：3
 * 解释：
 * horse -> rorse (将 'h' 替换为 'r')
 * rorse -> rose (删除 'r')
 * rose -> ros (删除 'e')
 *
 * 示例 2：
 * 输入：word1 = "intention", word2 = "execution"
 * 输出：5
 * 解释：
 * intention -> inention (删除 't')
 * inention -> enention (将 'i' 替换为 'e')
 * enention -> exention (将 'n' 替换为 'x')
 * exention -> exection (将 'n' 替换为 'c')
 * exection -> execution (插入 'u')
 *
 * 提示：
 * 0 <= word1.length, word2.length <= 500
 * word1 和 word2 由小写英文字母组成
 */

/**
 * 这里看，咱有三种操作：增，删，改
 * 但是我们可以看到，对word1的删，也可以看做是对word2的增
 * 所以咱现在的三种操作就变成了两种操作，并且咱舍去了最难的删操作
 * 现在是我们怎么表示呢？
 * 小看一眼题目标签，有动态规划，那我们就朝这个方向想，其实我们看到两个字符
 * 串我们就该想到动态规划了
 * 状态表示：dp[i][j]：使word1的前i个字符和word2的前j个字符相同的最少步数
 * HORSE -> RO    dp[i][j - 1]
 * ROS   -> HORS  dp[i - 1][j]
 * HORSE -> ROE   dp[i - 1][j - 1]
 *
 * 状态转移方程：dp[i][j] = Math.min(dp[i][j - 1], dp[i- 1][j], dp[j][j]) + 1
 * 我们提前开辟一行和一列避免越界
 * 怎么初始化呢？
 *
 * 在两个都为0的时候，就初始化为 0
 * 在一个为 0 一个为 1 的时候，我们与初始化为那个有字符的长度
 *
 * 时间复杂度 : O(n ^ 2)
 * 空间复杂度 : O(n ^ 2)
 */

public class Main {
    public int minDistance(String word1, String word2) {

        // 求出两个字符串的长度
        int m  =word1.length(), n = word2.length();

        int[][] dp = new int[m + 1][n + 1];

        // 初始化
        dp[0][0] = 0;

        for (int i = 1; i <= m; i++) {
            dp[i][0] = i;
        }

        for (int i = 1; i <= n; i++) {
            dp[0][i] = i;
        }

        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {

                // 对 word1 增加
                int a = dp[i - 1][j] + 1;

                // 对 word2 增加
                int b = dp[i][j - 1] + 1;

                // 修改 word1 中的最后一个单词
                int c = dp[i - 1][j - 1];

                // 这里要看一下最后一个单词是否一样, 要是一样的话就可以不用修改了
                if (word1.charAt(i - 1) != word2.charAt(j - 1)) {
                    c++;
                }

                // 取他们这间最小的
                dp[i][j] = Math.min(a, b);
                dp[i][j] = Math.min(dp[i][j], c);
            }
        }

        // 返回
        return dp[m][n];
    }
}